﻿package mortal.game.view.signUp.view
{
    import __AS3__.vec.*;
    import com.gengine.resource.*;
    import com.mui.controls.*;
    import com.mui.utils.*;
    import extend.language.*;
    import fl.data.*;
    import flash.display.*;
    import flash.events.*;
    import flash.geom.*;
    import flash.utils.*;
    import mortal.common.*;
    import mortal.common.global.*;
    import mortal.common.swfPlayer.*;
    import mortal.common.swfPlayer.data.*;
    import mortal.component.gconst.*;
    import mortal.game.cache.*;
    import mortal.game.events.*;
    import mortal.game.manager.*;
    import mortal.game.manager.msgTip.*;
    import mortal.game.mvc.*;
    import mortal.game.resource.*;
    import mortal.game.resource.tableConfig.*;
    import mortal.game.view.common.*;
    import mortal.game.view.common.display.*;
    import mortal.game.view.common.item.*;
    import mortal.game.view.signUp.data.*;
    import mortal.game.view.signUp.renderer.*;
    import mortal.game.view.signUp.util.*;
    import mortal.mvc.core.*;

    public class DailySignUpView extends SignUpViewBase
    {
        private var _totalSignNum:BitmapNumberText;
        private var _dateList:GTileList;
        private var _receiveRewardBtn1:GLoadingButton;
        private var _receiveRewardBtn2:GLoadingButton;
        private var _openVipBtn:GLoadingButton;
        private var _hasTakeBtn1:GLoadingButton;
        private var _hasTakeBtn2:GLoadingButton;
        private var _rewardTakeArrow1:SWFPlayer;
        private var _rewardTakeArrow2:SWFPlayer;
        private var _signUpRewardDaySpr:SignUpRewardDaySpr;
        private var _btnArr:Array;
        private var _commonRewardVec:Vector.<BaseItem>;
        private var _vipRewardVec:Vector.<BaseItem>;
        private const _totalDays:Array;
        private var _isInit:Boolean;
        private var _isCreateChildren:Boolean;

        public function DailySignUpView()
        {
            this._btnArr = [];
            this._commonRewardVec = new Vector.<BaseItem>;
            this._vipRewardVec = new Vector.<BaseItem>;
            this._totalDays = [1, 3, 5, 7, 12, 18, 26];
            return;
        }// end function

        override protected function createDisposedChildrenImpl() : void
        {
            super.createDisposedChildrenImpl();
            LoaderHelp.addResCallBack(ResFileConst.DailySignUp, this.onResLoadCompl);
            GameProxy.checkIn.getCheckInInfo();
            return;
        }// end function

        private function onResLoadCompl() : void
        {
            if (isDisposed)
            {
                return;
            }
            this.createChildren();
            return;
        }// end function

        private function createChildren() : void
        {
            var _loc_4:int = 0;
            var _loc_5:int = 0;
            var _loc_6:BaseItem = null;
            this._isCreateChildren = true;
            this.pushUIToDisposeVec(UIFactory.bg(203 - 203, 66 - 66, 691, 541, this));
            this.pushUIToDisposeVec(UIFactory.gImageBitmap(ImagesConst.SignUpGiftImg, 204 - 203, 47 + 21 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_MoreGift, 272 - 203, 72 - 66, this));
            var _loc_1:* = GlobalStyle.textFormatHuang;
            _loc_1.size = 15;
            this.pushUIToDisposeVec(UIFactory.gTextField(Language.getString(41379), 713 - 203, 78 - 66, 122, 25, this, _loc_1));
            this._totalSignNum = UIFactory.bitmapNumberText(828 - 203, 78 - 66, "SignUpNum2.png", 22, 23, -6, this);
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.SignUpWeekTitleBg, 202 - 203, 109 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_Sun, 241 - 4 - 203, 119 - 4 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_Mon, 337 - 4 - 203, 119 - 4 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_Tue, 434 - 4 - 203, 119 - 4 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_Wed, 531 - 4 - 203, 119 - 4 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_Thu, 628 - 4 - 203, 119 - 4 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_Fri, 725 - 4 - 203, 119 - 4 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_Sat, 822 - 4 - 203, 119 - 4 - 66, this));
            this._dateList = UIFactory.tileList(6, 142 - 66, 687, 216, this);
            this._dateList.columnWidth = 97;
            this._dateList.rowHeight = 42;
            this._dateList.horizontalGap = 0;
            this._dateList.verticalGap = 0;
            this._dateList.setStyle("skin", new Bitmap());
            this._dateList.setStyle("cellRenderer", SignUpDateCellRenderer);
            var _loc_2:int = 0;
            while (_loc_2 < 8)
            {
                
                _loc_4 = 208 - 203 + 97 * _loc_2;
                _loc_5 = 142 - 66;
                this.pushUIToDisposeVec(UIFactory.bg(_loc_4, _loc_5, 1, 211, this, ImagesConst.SplitLine5));
                _loc_2++;
            }
            _loc_2 = 0;
            while (_loc_2 < 5)
            {
                
                _loc_4 = 208 - 203;
                _loc_5 = 184 - 66 + 42 * _loc_2;
                this.pushUIToDisposeVec(UIFactory.bg(_loc_4, _loc_5, 679, 1, this, ImagesConst.SplitLine4));
                _loc_2++;
            }
            this.pushUIToDisposeVec(UIFactory.bg(202 - 203, 352 + 4 - 66, 687 + 6, 37, this, ImagesConst.TextBg5));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.GroupCopySide, 390 - 14 - 203, 368 - 66, this));
            var _loc_3:* = UIFactory.gBitmap(ImagesConst.GroupCopySide, 662 + 68 - 203, 368 - 66, this);
            _loc_3.scaleX = -1;
            this.pushUIToDisposeVec(_loc_3);
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.Text_TotalReward, 453 - 203, 362 - 66, this));
            this.pushUIToDisposeVec(UIFactory.gTextField(Language.getString(41380), 756 - 203, 362 - 66, 137, 20, this, GlobalStyle.textFormatHuang2));
            this.pushUIToDisposeVec(UIFactory.gImageBitmap(ImagesConst.SignUpRewardBg, 204 - 203, 417 - 29 - 66, this));
            this._signUpRewardDaySpr = UICompomentPool.getUICompoment(SignUpRewardDaySpr);
            this._signUpRewardDaySpr.x = 209 - 203;
            this._signUpRewardDaySpr.y = 387 - 66;
            this.addChild(this._signUpRewardDaySpr);
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.SignUpHuawen, 233 - 6 - 203, 440 - 66, this));
            _loc_3 = UIFactory.gBitmap(ImagesConst.SignUpHuawen, 439 + 87 - 203, 440 - 66, this);
            _loc_3.scaleX = -1;
            _loc_1 = GlobalStyle.textFormatHuang2;
            _loc_1.size = 14;
            this.pushUIToDisposeVec(UIFactory.gTextField(Language.getString(41381), 318 - 203, 429 - 66, 126, 25, this, _loc_1));
            this.pushUIToDisposeVec(UIFactory.bg(257 - 203, 454 - 66, 241, 110, this, ImagesConst.SignUpRewardSmallBg));
            this.pushUIToDisposeVec(UIFactory.gBitmap(ImagesConst.SignUpHuawen, 574 - 203, 440 - 66, this));
            _loc_3 = UIFactory.gBitmap(ImagesConst.SignUpHuawen, 775 + 85 - 203, 440 - 66, this);
            _loc_3.scaleX = -1;
            this.pushUIToDisposeVec(UIFactory.gTextField(Language.getString(41382), 662 - 203, 429 - 66, 126, 25, this, _loc_1));
            this.pushUIToDisposeVec(UIFactory.bg(257 + 343 - 203, 454 - 66, 241, 110, this, ImagesConst.SignUpRewardSmallBg));
            _loc_2 = 0;
            while (_loc_2 < 8)
            {
                
                _loc_6 = UICompomentPool.getUICompoment(BaseItem);
                _loc_6.setItemStyle(ItemStyleConst.Small, ImagesConst.PackItemBg, 2, 2);
                _loc_6.x = 102 - 26 + int(_loc_2 % 4) * 52;
                _loc_6.y = 406 + int(_loc_2 / 4) * 45;
                this.addChild(_loc_6);
                _loc_6.isDragAble = false;
                _loc_6.visible = false;
                this._commonRewardVec.push(_loc_6);
                this.pushUIToDisposeVec(_loc_6);
                _loc_2++;
            }
            _loc_2 = 0;
            while (_loc_2 < 8)
            {
                
                _loc_6 = UICompomentPool.getUICompoment(BaseItem);
                _loc_6.setItemStyle(ItemStyleConst.Small, ImagesConst.PackItemBg, 2, 2);
                _loc_6.x = 444 - 23 + int(_loc_2 % 4) * 52;
                _loc_6.y = 406 + int(_loc_2 / 4) * 45;
                this.addChild(_loc_6);
                _loc_6.isDragAble = false;
                _loc_6.visible = false;
                this._vipRewardVec.push(_loc_6);
                this.pushUIToDisposeVec(_loc_6);
                _loc_2++;
            }
            this._receiveRewardBtn1 = UIFactory.gLoadingButton(ResFileConst.ReceiveRewardBtn, 130, 508, 91, 27, this);
            this._receiveRewardBtn1.filterEnabled = false;
            this._receiveRewardBtn1.configEventListener(MouseEvent.CLICK, this.onBtnClickHandler);
            this._btnArr.push(this._receiveRewardBtn1);
            this._openVipBtn = UIFactory.gLoadingButton(ResFileConst.OpenVipBtn, 473, 508, 91, 27, this);
            this._openVipBtn.configEventListener(MouseEvent.CLICK, this.onBtnClickHandler);
            this._btnArr.push(this._openVipBtn);
            this._receiveRewardBtn2 = UIFactory.gLoadingButton(ResFileConst.ReceiveRewardBtn, 473, 508, 91, 27, this);
            this._receiveRewardBtn2.filterEnabled = false;
            this._receiveRewardBtn2.configEventListener(MouseEvent.CLICK, this.onBtnClickHandler);
            this._btnArr.push(this._receiveRewardBtn2);
            this._hasTakeBtn1 = UIFactory.gLoadingButton(ResFileConst.HasTakenBtn, 130, 508, 93, 30, this);
            this._hasTakeBtn2 = UIFactory.gLoadingButton(ResFileConst.HasTakenBtn, 473, 508, 93, 30, this);
            this._btnArr.push(this._hasTakeBtn1);
            this._btnArr.push(this._hasTakeBtn2);
            this._rewardTakeArrow1 = UICompomentPool.getUICompoment(SWFPlayer);
            this._rewardTakeArrow2 = UICompomentPool.getUICompoment(SWFPlayer);
            this.addListeners();
            this.initUI();
            return;
        }// end function

        private function addListeners() : void
        {
            NetDispatcher.addCmdListener(ServerCommand.SignUpGetRewardSucc, this.getRewardSuccHandler);
            Dispatcher.addEventListener(EventName.SignUpSwitchDayTag, this.onSwitchDayTagHandler);
            return;
        }// end function

        private function removeListeners() : void
        {
            NetDispatcher.removeCmdListener(ServerCommand.SignUpGetRewardSucc, this.getRewardSuccHandler);
            Dispatcher.removeEventListener(EventName.SignUpSwitchDayTag, this.onSwitchDayTagHandler);
            return;
        }// end function

        private function initUI() : void
        {
            this.initBtn();
            return;
        }// end function

        private function initBtn() : void
        {
            DisplayUtil.removeMe(this._openVipBtn);
            DisplayUtil.removeMe(this._hasTakeBtn1);
            DisplayUtil.removeMe(this._hasTakeBtn2);
            return;
        }// end function

        public function updateAll() : void
        {
            this.updateTotalSignUpNum();
            this.updateDateList();
            this.updateRewardDays();
            if (!this._isInit)
            {
                this.setDefaultDayRewards();
                this._isInit = true;
            }
            this.updateRewardInfo();
            return;
        }// end function

        private function setDefaultDayRewards() : void
        {
            var _loc_1:* = SignUpUtil.getDefaultDay();
            this._signUpRewardDaySpr.setDefaultTag(_loc_1);
            return;
        }// end function

        private function updateDateList() : void
        {
            var _loc_1:* = Cache.instance.signUp.getSignUpData();
            var _loc_2:* = new DataProvider();
            _loc_2.addItems(_loc_1);
            this._dateList.dataProvider = _loc_2;
            this._dateList.drawNow();
            this.updateTotalSignUpNum();
            return;
        }// end function

        private function updateTotalSignUpNum() : void
        {
            this._totalSignNum.text = Cache.instance.signUp.totalSignUpNum + "";
            return;
        }// end function

        private function updateRewardDays() : void
        {
            var _loc_2:int = 0;
            var _loc_3:SignUpTotalDayData = null;
            var _loc_4:int = 0;
            var _loc_1:Array = [];
            for each (_loc_2 in this._totalDays)
            {
                
                _loc_3 = new SignUpTotalDayData();
                _loc_3.totalDayNum = _loc_2;
                _loc_4 = _loc_2 - Cache.instance.signUp.totalSignUpNum;
                if (_loc_4 <= 0)
                {
                    _loc_3.dayNum = _loc_2;
                    _loc_3.isAchieve = true;
                }
                else
                {
                    _loc_3.dayNum = _loc_4;
                }
                _loc_1.push(_loc_3);
            }
            this._signUpRewardDaySpr.data = _loc_1;
            return;
        }// end function

        private function updateRewardInfo() : void
        {
            if (this._signUpRewardDaySpr.currSelTag && this._signUpRewardDaySpr.currSelTag.signUpTotalDayData)
            {
                this.clear();
                this.updateCommonRewardInfo(this._signUpRewardDaySpr.currSelTag.signUpTotalDayData.totalDayNum);
                this.updateVipRewardInfo(this._signUpRewardDaySpr.currSelTag.signUpTotalDayData.totalDayNum);
            }
            return;
        }// end function

        private function updateCommonRewardInfo(param1:int) : void
        {
            var _loc_5:String = null;
            var _loc_2:* = CheckInAwardsConfig.instance.getRewardsByTotalNum(param1, false);
            var _loc_3:* = _loc_2.split("&");
            var _loc_4:int = 0;
            while (_loc_4 < _loc_3.length)
            {
                
                _loc_5 = _loc_3[_loc_4];
                this._commonRewardVec[_loc_4].itemCode = int(_loc_5.split("#")[0]);
                this._commonRewardVec[_loc_4].amount = int(_loc_5.split("#")[1]);
                this._commonRewardVec[_loc_4].isShowLock = true;
                this._commonRewardVec[_loc_4].isBind = true;
                this._commonRewardVec[_loc_4].visible = true;
                _loc_4++;
            }
            this.setRewardState(param1, false);
            return;
        }// end function

        private function updateVipRewardInfo(param1:int) : void
        {
            var _loc_6:String = null;
            var _loc_2:* = CheckInAwardsConfig.instance.getRewardsByTotalNum(param1, true);
            var _loc_3:* = _loc_2.split("&");
            var _loc_4:int = 0;
            while (_loc_4 < _loc_3.length)
            {
                
                _loc_6 = _loc_3[_loc_4];
                this._vipRewardVec[_loc_4].itemCode = int(_loc_6.split("#")[0]);
                this._vipRewardVec[_loc_4].amount = int(_loc_6.split("#")[1]);
                this._vipRewardVec[_loc_4].isShowLock = true;
                this._vipRewardVec[_loc_4].isBind = true;
                this._vipRewardVec[_loc_4].visible = true;
                _loc_4++;
            }
            var _loc_5:* = Cache.instance.vip.level > 0 ? (true) : (false);
            if (_loc_5)
            {
                this.setRewardState(param1, true);
            }
            else if (!this._openVipBtn.parent)
            {
                DisplayUtil.removeMe(this._receiveRewardBtn2);
                this.addChild(this._openVipBtn);
                this._openVipBtn.x = 473;
                this._openVipBtn.y = 508;
            }
            return;
        }// end function

        private function onSwitchDayTagHandler(event:DataEvent) : void
        {
            this.updateRewardInfo();
            return;
        }// end function

        private function setRewardState(param1:int, param2:Boolean) : void
        {
            var _loc_3:* = CheckInAwardsConfig.instance.getRewardIdByDays(param1, param2);
            var _loc_4:* = Cache.instance.signUp.getRewardTakeState(_loc_3);
            if (_loc_4.isCanTake)
            {
                this.setRewardItemState(param2, true);
                if (_loc_4.isTake)
                {
                    this.setBtnState(param2, SignUpConst.State_HasTaken);
                }
                else
                {
                    this.setBtnState(param2, SignUpConst.State_CanTake);
                }
            }
            else
            {
                this.setRewardItemState(param2, false);
                this.setBtnState(param2, SignUpConst.State_CanNotTake);
            }
            return;
        }// end function

        private function setRewardItemState(param1:Boolean, param2:Boolean) : void
        {
            var _loc_3:Vector.<BaseItem> = null;
            var _loc_4:BaseItem = null;
            if (param1)
            {
                _loc_3 = this._vipRewardVec;
            }
            else
            {
                _loc_3 = this._commonRewardVec;
            }
            if (param2)
            {
                for each (_loc_4 in _loc_3)
                {
                    
                    _loc_4.filters = [];
                }
            }
            else
            {
                for each (_loc_4 in _loc_3)
                {
                    
                    _loc_4.filters = [FilterConst.colorFilter2];
                }
            }
            return;
        }// end function

        private function setBtnState(param1:Boolean, param2:int) : void
        {
            var _loc_3:* = this.getCurrBtnByState(param1, param2);
            if (param1)
            {
                _loc_3 = this._receiveRewardBtn2;
            }
            else
            {
                _loc_3 = this._receiveRewardBtn1;
            }
            if (param2 == SignUpConst.State_CanTake)
            {
                _loc_3.filterEnabled = true;
                EffectManager.glowFilterReg(_loc_3);
                if (param1)
                {
                    this.addArrow2();
                }
                else
                {
                    this.addArrow1();
                }
            }
            else
            {
                _loc_3.filterEnabled = false;
                EffectManager.glowFilterUnReg(_loc_3);
                if (param1)
                {
                    this.removeArrow2();
                }
                else
                {
                    this.removeArrow1();
                }
            }
            return;
        }// end function

        private function getCurrBtnByState(param1:Boolean, param2:int) : GLoadingButton
        {
            var _loc_3:GLoadingButton = null;
            switch(param2)
            {
                case SignUpConst.State_CanTake:
                case SignUpConst.State_CanNotTake:
                {
                    if (!this._receiveRewardBtn2.parent)
                    {
                    }
                    break;
                }
                case SignUpConst.State_HasTaken:
                {
                    if (!this._hasTakeBtn2.parent)
                    {
                    }
                    break;
                }
                default:
                {
                    break;
                }
            }
            switch(param2)
            {
                case SignUpConst.State_CanTake:
                case SignUpConst.State_CanNotTake:
                {
                    if (!this._receiveRewardBtn1.parent)
                    {
                    }
                    break;
                }
                case SignUpConst.State_HasTaken:
                {
                    if (!this._hasTakeBtn1.parent)
                    {
                    }
                    break;
                }
                default:
                {
                    break;
                }
            }
            return _loc_3;
        }// end function

        private function onBtnClickHandler(event:MouseEvent) : void
        {
            var _loc_2:int = 0;
            var _loc_3:int = 0;
            if (this._signUpRewardDaySpr.currSelTag && this._signUpRewardDaySpr.currSelTag.signUpTotalDayData)
            {
                _loc_2 = this._signUpRewardDaySpr.currSelTag.signUpTotalDayData.totalDayNum;
            }
            if (event.target == this._receiveRewardBtn1)
            {
                _loc_3 = CheckInAwardsConfig.instance.getRewardIdByDays(_loc_2, false);
                if (_loc_3 == 0)
                {
                    MsgManager.showMouseMsg(Language.getString(41383), MsgRollTipsType.msgRollTips1);
                    return;
                }
                if (Cache.instance.pack.backPackCache.isPackFull())
                {
                    MsgManager.showMouseMsg(Language.getString(41384), MsgRollTipsType.msgRollTips3);
                    return;
                }
                GameProxy.checkIn.setCheckInAward(_loc_3, false);
            }
            if (event.target == this._receiveRewardBtn2)
            {
                _loc_3 = CheckInAwardsConfig.instance.getRewardIdByDays(_loc_2, true);
                if (_loc_3 == 0)
                {
                    MsgManager.showMouseMsg(Language.getString(41385), MsgRollTipsType.msgRollTips1);
                    return;
                }
                if (Cache.instance.pack.backPackCache.isPackFull())
                {
                    MsgManager.showMouseMsg(Language.getString(41386), MsgRollTipsType.msgRollTips3);
                    return;
                }
                GameProxy.checkIn.setCheckInAward(_loc_3, true);
            }
            if (event.target == this._openVipBtn)
            {
                GameController.vip.view.show();
            }
            return;
        }// end function

        private function getRewardSuccHandler(param1:Object) : void
        {
            var obj:* = param1;
            var isVipReward:* = obj as Boolean;
            this.flyToBag(isVipReward);
            var roleLevel:* = Cache.instance.role.entityInfo.level;
            if (!(SignUpUtil.isSignUpAvailable() || SignUpUtil.hasRewardToTake()) && roleLevel < (GameConst.SignUpOpenLevel + 1))
            {
                var closeWin:* = function () : void
            {
                GameController.signUp.view.hide();
                return;
            }// end function
            ;
                setTimeout(closeWin, 500);
            }
            return;
        }// end function

        public function flyToBag(param1:Boolean) : void
        {
            var _loc_3:BaseItem = null;
            var _loc_4:Point = null;
            var _loc_2:* = param1 ? (this._vipRewardVec) : (this._commonRewardVec);
            for each (_loc_3 in _loc_2)
            {
                
                _loc_4 = _loc_3.localToGlobal(new Point(0, 0));
                if (_loc_3)
                {
                    FlyToNavbarTool.flyToBackPack(_loc_3.bitmapdata, _loc_4);
                }
            }
            return;
        }// end function

        private function onVipUpdateHandler(param1:Object) : void
        {
            GameProxy.checkIn.getCheckInInfo();
            return;
        }// end function

        private function clear() : void
        {
            this.clearRewardItemState();
            this.clearBtnState();
            return;
        }// end function

        private function clearRewardItemState() : void
        {
            var _loc_1:BaseItem = null;
            for each (_loc_1 in this._commonRewardVec)
            {
                
                _loc_1.itemData = null;
                _loc_1.visible = false;
                _loc_1.filters = [];
            }
            for each (_loc_1 in this._vipRewardVec)
            {
                
                _loc_1.itemData = null;
                _loc_1.visible = false;
                _loc_1.filters = [];
            }
            return;
        }// end function

        private function clearBtnState() : void
        {
            var _loc_1:GLoadingButton = null;
            for each (_loc_1 in this._btnArr)
            {
                
                DisplayUtil.removeMe(_loc_1);
            }
            this._receiveRewardBtn1.filterEnabled = false;
            this._receiveRewardBtn2.filterEnabled = false;
            this._openVipBtn.filterEnabled = true;
            EffectManager.glowFilterUnReg(this._receiveRewardBtn1);
            EffectManager.glowFilterUnReg(this._receiveRewardBtn2);
            EffectManager.glowFilterUnReg(this._openVipBtn);
            this.removeArrow1();
            this.removeArrow2();
            return;
        }// end function

        private function addArrow1() : void
        {
            this._rewardTakeArrow1.timeRate = 2;
            this._rewardTakeArrow1.load("guideArrow.swf", ModelType.NormalSwf, null);
            this._rewardTakeArrow1.move(this._receiveRewardBtn1.x - 10, this._receiveRewardBtn1.y + 10);
            this.addChild(this._rewardTakeArrow1);
            return;
        }// end function

        private function removeArrow1() : void
        {
            DisplayUtil.removeMe(this._rewardTakeArrow1);
            return;
        }// end function

        private function addArrow2() : void
        {
            this._rewardTakeArrow2.timeRate = 2;
            this._rewardTakeArrow2.load("guideArrow.swf", ModelType.NormalSwf, null);
            this._rewardTakeArrow2.move(this._receiveRewardBtn2.x - 10, this._receiveRewardBtn2.y + 10);
            this.addChild(this._rewardTakeArrow2);
            return;
        }// end function

        private function removeArrow2() : void
        {
            DisplayUtil.removeMe(this._rewardTakeArrow2);
            return;
        }// end function

        public function get isCreateChildren() : Boolean
        {
            return this._isCreateChildren;
        }// end function

        override protected function disposeImpl(param1:Boolean = true) : void
        {
            super.disposeImpl(param1);
            if (!this._isCreateChildren)
            {
                return;
            }
            this._isCreateChildren = false;
            EffectManager.glowFilterUnReg(this._receiveRewardBtn1);
            EffectManager.glowFilterUnReg(this._receiveRewardBtn2);
            EffectManager.glowFilterUnReg(this._openVipBtn);
            this._totalSignNum.dispose(param1);
            this._dateList.dispose(param1);
            this._signUpRewardDaySpr.dispose(param1);
            this._receiveRewardBtn1.dispose(param1);
            this._receiveRewardBtn2.dispose(param1);
            this._openVipBtn.dispose(param1);
            this._rewardTakeArrow1.dispose();
            this._rewardTakeArrow2.dispose();
            this._hasTakeBtn1.dispose();
            this._hasTakeBtn2.dispose();
            this._totalSignNum = null;
            this._dateList = null;
            this._signUpRewardDaySpr = null;
            this._receiveRewardBtn1 = null;
            this._receiveRewardBtn2 = null;
            this._openVipBtn = null;
            this._rewardTakeArrow1 = null;
            this._rewardTakeArrow2 = null;
            this._hasTakeBtn1 = null;
            this._hasTakeBtn2 = null;
            this._commonRewardVec.length = 0;
            this._vipRewardVec.length = 0;
            this._btnArr.length = 0;
            this._isInit = false;
            this.removeListeners();
            return;
        }// end function

    }
}
